package dao;

import dto.DTOInmueble;
import java.util.Vector;
import entidades.Inmueble;


/**
 * Clase de la capa de Persistencia, encargada de recuperar y almacenar objetos
 * Inmueble en la base de datos.
 * 
 */
public class DAOInmueble extends DAO {
    /**
     * Retorna el vector de objetos Inmueble cargadas en la base de datos.
     *
     * @return Vector   El vector de objetos Inmueble, null si no existe
     */
    public static Vector<Inmueble> getAll() {
        return getAll("Inmueble");
    }

    /**
     * Obtiene los inmuebles que cumplan con los criterios especificados
     * 
     * @param criterios DTOInmueble criterios de búsqueda 
     * @return Vector   Arreglo de inmuebles que coincidieron 
     */
    public static Vector<Inmueble> filtrarInmuebles(DTOInmueble criterios) {
        String query = "Inmueble ";
        boolean tiene_una_condicion = false;

	if(criterios.getIdLocalidad() != -1) {
            query += " where ";
            tiene_una_condicion = true;
            query += "localidad.idLocalidad = "+criterios.getIdLocalidad();
	}
	else
            if(criterios.getIdProvincia() != -1) {
		query += " where ";
		tiene_una_condicion = true;
		query += " (localidad.provincia.idProvincia = "+ criterios.getIdProvincia() +")";
            }

        if(!criterios.getBarrio().isEmpty()) {
            if(tiene_una_condicion) {
                query += " and ";
            }
            else {
                query += " where ";
                tiene_una_condicion = true;
            }

            query += " barrio LIKE '%"+criterios.getBarrio()+"%'";
        }

        if(!criterios.getTipo().isEmpty()) {
            if(tiene_una_condicion) {
                query += " and ";
            }
            else {
                query += " where ";
                tiene_una_condicion = true;
            }

            query += " tipo = '"+criterios.getTipo()+"'";
        }

        if(criterios.getDormitorios() != -1) {
            if(tiene_una_condicion) {
                query += " and ";
            }
            else {
                query += " where ";
                tiene_una_condicion = true;
            }

            query += " dormitorios = "+criterios.getDormitorios();
        }

        if (criterios.getPrecioDesde() != -1){
            if (criterios.getPrecioHasta() != -1) {
            // busca por PRECIO DESDE y PRECIO HASTA
                if(tiene_una_condicion) {
                    query += " and ";
                }
                else {
                    query += " where ";
                    tiene_una_condicion = true;
                }

                query += " precio between "+criterios.getPrecioDesde()+" and "+criterios.getPrecioHasta();
            }
            else {
            // busca solo por PRECIO DESDE
                if(tiene_una_condicion) {
                    query += " and ";
                }
                else {
                    query += " where ";
                    tiene_una_condicion = true;
                }

                query += " precio >= "+criterios.getPrecioDesde();
            }
        }
        else 
            if (criterios.getPrecioHasta() != -1) {
            // busca solo por PRECIO HASTA
                if(tiene_una_condicion) {
                    query += " and ";
                }
                else {
                    query += " where ";
                    tiene_una_condicion = true;
                }

                query += " precio <= "+criterios.getPrecioHasta();
            }
        
        return get(query);
    }

    /**
     * Obtiene los inmuebles que coincidan con la consulta especificada
     * @param query Consulta con las condiciones (HQL)
     * @return Vector   Inmuebles que coincidieron con la búsqueda
     */
    public static Vector<Inmueble> get(String query) {
        return getAll(query);
    }

    /**
     * Obtiene el inmueble que coincide con el id especificado
     * @param idInmueble ID del inmueble
     * @return Inmueble con el id que se pasó como parametro. Null en caso contrario
     */
    public static Inmueble getByID(Integer idInmueble) {
        Vector<Inmueble> inmueble = get("Inmueble where idInmueble = "+idInmueble);
        
        if(!inmueble.isEmpty()) {
            return inmueble.get(0);
        }
        else {
            return null;
        }   
    }
    
    /**
     * Obtiene el inmueble a partir de su código único  
     * @param codigoInmueble    Código del inmueble que se desea obtener
     * @return Inmueble El inmueble encontado. Null si ningún inmueble coincide 
     *                  con el código especificado
     */
    public static Inmueble getByCodigo(String codigoInmueble) {
        Vector<Inmueble> inmueble = null;
        try {
             inmueble = get("Inmueble where codigo = '" + codigoInmueble + "'");
        } catch (Exception e) {
            System.out.println("no anduvo");
        }

        if(!inmueble.isEmpty()) {
            return inmueble.get(0);
        }
        else {
            return null;
        }   
   }
   
    /**
     * Obtiene el Inmueble con el mayor ID
     * 
     * @return Inmueble Inmueble con el mayor ID de todos.
     */
   public static Inmueble getMaxId() {
        Vector<Inmueble> inmueble = null;
        try {
             inmueble = get("Inmueble where idInmueble = (SELECT MAX(idInmueble) FROM Inmueble)");
        } catch (Exception e) {
            System.out.println("no anduvo");
        }

        if(!inmueble.isEmpty()) {
            return inmueble.get(0);
        }
        else {
            return null;
        }   
   }
    
   /**
    * Inserta (persiste) un inmueble en la base de datos
    * @param i Inmueble Inmueble que se desea insertar
    * @return true si fue exitoso, false en caso contrario
    */
    public static boolean insert(Inmueble i) {
        return guardarOActualizarObjeto(i);
    }

    /**
    * Actualiza (persiste) un inmueble en la base de datos
    * @param i Inmueble Inmueble que se desea actualizar
    * @return true si fue exitoso, false en caso contrario
    */
    public static boolean update(Inmueble i) {
        return guardarOActualizarObjeto(i);
    }

    /**
    * Borra (elimina) un inmueble en la base de datos
    * @param i Inmueble Inmueble que se desea eliminar
    * @return true si fue exitoso, false en caso contrario
    */
    public static boolean delete(Inmueble i) {
        
        return eliminarObjeto(i);
    }

    /**
     * Genera un vector con los atributos de un inmueble que se ubican en una tabla
     * con el listado de inmuebles.
     * 
     * @param i Inmueble Inmueble del que se quiere obtener el vector con los atributos
     * @return Vector Arreglo con los datos que se incorporan en una fila de una tabla
     */
    public static Vector convertirInmuebleParaMostrarEnTabla(Inmueble i) {
        Vector inmueble = new Vector();
        
        inmueble.add(i.getCodigo());
        inmueble.add(i.getCalle()+" "+i.getNumero());
        inmueble.add(i.getBarrio());
        inmueble.add(i.getTipo());
        
        return inmueble;
    }

    /**
     * Obtiene los inmuebles de un determinado propietario
     * @param idPropietario ID del propietario
     * @return Vector
     */
    public static Vector<Inmueble> getByIdPropietario(int idPropietario) {
        return getAll("Inmueble where propietario.idPropietario = "+idPropietario);
    }
    
    /**
     * Tipos de inmuebles
     */
    public enum TipoInmueble{
        LOCAL_OFICINA,
        CASA,
        DEPARTAMENTO,
        TERRENO,
        QUINTA,
        GALPON;
    }

    /**
     * Orientaciones que puede tener un inmueble
     */
    public enum TipoOrientacion{
        NORTE,
        SUR,
        ESTE,
        OESTE,
        NORESTE,
        NOROESTE,
        SURESTE,
        SUROESTE;
    }
    
    /**
     * Indica a qué tipo de inmueble corresponde la inicial indicada
     * @param inmuebleTipo Inicial del tipo de inmueble
     * @return Tipo de inmueble
     */
    public static DAOInmueble.TipoInmueble getInmuebleTipoEnum(String inmuebleTipo) {
        if (inmuebleTipo.equals("L"))
            return DAOInmueble.TipoInmueble.LOCAL_OFICINA;
        
        if ("C".equals(inmuebleTipo))
            return DAOInmueble.TipoInmueble.CASA;
        
        if (inmuebleTipo.equals("D"))
            return DAOInmueble.TipoInmueble.DEPARTAMENTO;
        
        if ("T".equals(inmuebleTipo))
            return DAOInmueble.TipoInmueble.TERRENO;
        
        if ("Q".equals(inmuebleTipo))
            return DAOInmueble.TipoInmueble.QUINTA;
        
        if ("G".equals(inmuebleTipo))
            return DAOInmueble.TipoInmueble.GALPON;
        
        return null;
    }
    
    /**
     * Obtiene el tipo de inmueble al que corresponde el índice de un combo box
     * @param cbIndex Índice seleccionado
     * @return Inicial del tipo de inmueble
     */
    public static String setInmuebleTipoEnum(int cbIndex) {
        String inmuebleTipo = null;
        switch (cbIndex){
            case -1:
                inmuebleTipo="";
                break;
                
            case 0:
                inmuebleTipo="L";
                break;
                
            case 1:
                inmuebleTipo="C";
                break;
                
            case 2:
                inmuebleTipo="D";
                break;
                
            case 3:
                inmuebleTipo="T";
                break;
                
            case 4:
                inmuebleTipo="Q";
                break;
                
            case 5:
                inmuebleTipo="G";
        }
        return inmuebleTipo;
    }
    
    /**
     * Obtiene la orientación del inmueble a partir de su inicial
     * 
     * @param orientacion String Inicial de la orientación especificada
     * @return La orientación del inmueble
     */
    public static DAOInmueble.TipoOrientacion getOrientacionEnum(String orientacion) {
        
        if (orientacion.equals("N"))
            return DAOInmueble.TipoOrientacion.NORTE;
        
        if (orientacion.equals("S"))
            return DAOInmueble.TipoOrientacion.SUR;
        
        if (orientacion.equals("E"))
            return DAOInmueble.TipoOrientacion.ESTE;
        
        if (orientacion.equals("O"))
            return DAOInmueble.TipoOrientacion.OESTE;
        
        if (orientacion.equals("NE"))
            return DAOInmueble.TipoOrientacion.NORESTE;
        
        if (orientacion.equals("NO"))
            return DAOInmueble.TipoOrientacion.NOROESTE;
        
        if (orientacion.equals("SE"))
            return DAOInmueble.TipoOrientacion.SURESTE;
        
        if (orientacion.equals("SO"))
            return DAOInmueble.TipoOrientacion.SUROESTE;
        
        return null;
    }
    
    /**
     * Indica a qué orientación corresponde el índice de un ComboBox
     * 
     * @param cbIndex int Índice
     * @return Inicial de la orientación
     */
    public static String setOrientacionEnum(int cbIndex) {
        String inmuebleOrientacion = null;
              switch (cbIndex){
            case 0:
                inmuebleOrientacion="N";
                break;
                
            case 1:
                inmuebleOrientacion="S";
                break;
                
            case 2:
                inmuebleOrientacion="E";
                break;
                
            case 3:
                inmuebleOrientacion="O";
                break;
                
            case 4:
                inmuebleOrientacion="NE";
                break;
                
            case 5:
                inmuebleOrientacion="NO";
                break;
            case 6:
                inmuebleOrientacion="SE";
                break;
            case 7:
                inmuebleOrientacion="SO";
                break;
        }
        return inmuebleOrientacion;
    }
}
